home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / util / cdity / ModeProSrc.lha / Prefs / MPP_PI.c < prev    next >
C/C++ Source or Header  |  1999-01-11  |  16KB  |  813 lines
  1. //#include "/ModePro.h"
  2. //#include "mpp.h"
  3. #include "mppexterns.h"
  4. #include <stdio.h>
  5.  
  6. extern struct LG_Control *GadControl;
  7. extern LONG ActivePen;
  8. extern BOOL ClosePrefs;
  9. extern struct Window *Win;
  10. extern UWORD defaultpens[];
  11. extern UWORD NumDriPens;
  12. extern STRPTR MiscText[];
  13. extern ULONG ListToCyc[];
  14. extern  WORD CurrentList_2,
  15.              CurrentList;
  16. extern  LONG LVActive,
  17.              NodeCnt;
  18. extern ULONG ActivateStrGad;
  19. extern UBYTE EnvFile[],
  20.              EnvArcFile[];
  21. extern struct MPSem   *MPSem;
  22. extern struct List ForcedEditList;
  23. extern struct MPMessage *ForcedEditMsg;
  24. extern UBYTE    filename[513];
  25. extern struct Window   *Win;
  26.  
  27. void ReturnFEMsg(ULONG Code);
  28. BOOL SetDNFlag(struct DefaultNode *N, ULONG Flag, BOOL Set, BOOL Keyed);
  29.  
  30.  
  31. void GD_Type(LONG Code)
  32. {
  33.   if(Code>MAX_TYPE)
  34.     Code=0;
  35.   else
  36.     if(Code<0)
  37.       Code=MAX_TYPE;
  38.  
  39.   CurrentList_2=Code;
  40.   CurrentList=ListToCyc[Code];
  41.   LVActive=0;
  42.   UpdateGadgets();
  43. }
  44.  
  45. struct DefaultNode *GD_New(void)
  46. {
  47.   struct DefaultNode *n;
  48.   ULONG l;
  49.   
  50.   if(n=AllocDefaultNode(0))
  51.   {
  52.     if(CurrentList!=MPSEM_PLIST_SCREENMODES)
  53.       n->Def_Node.ln_Name=CopyString(MiscText[ITEM_NEW_NAME], MEMF_CLEAR | MEMF_PUBLIC);
  54.     else
  55.       n->Def_Node.ln_Name=GetModeName(0);
  56.       
  57.     n->Type=CurrentList;
  58.     n->OverscanType=1;
  59.     for(l=0;l<NumDriPens;l++)
  60.       n->Pens[l]=defaultpens[l];
  61.   
  62.     ObtainSemaphore(&MPSem->NodeSem);
  63.     LG_SetGadgetAttrs(GadControl,GD_LIST,
  64.                      GTLV_Labels      ,~0,
  65.                      GTLV_Selected    ,0,
  66.                      TAG_DONE);
  67.     AddHead(&MPSem->PromotionList[CurrentList],(struct Node *)n);
  68.     LVActive=0;
  69.         
  70.     ReleaseSemaphore(&MPSem->NodeSem);
  71.     UpdateGadgets();
  72.     ActivateStrGad=GD_NAME;
  73.   } 
  74.   return(n);
  75. } 
  76.  
  77. void GD_Save(void)
  78. {
  79.   ClosePrefs=TRUE;
  80.   ObtainSemaphore(&MPSem->NodeSem);
  81.   PrefSaveFile(EnvArcFile);
  82.   PrefSaveFile(EnvFile);
  83.   ReleaseSemaphore(&MPSem->NodeSem);
  84. }
  85.  
  86. void GD_Use(void)
  87. {
  88.   ClosePrefs=TRUE;
  89.   PrefSaveFile(EnvFile);
  90. }
  91.  
  92. void GD_Cancel(void)
  93. {
  94.   ObtainSemaphore(&MPSem->NodeSem);
  95.   LG_SetGadgetAttrs(GadControl,GD_LIST,
  96.                     GTLV_Labels,~0,TAG_DONE);
  97.   FreeAllDefLists(MPSem->PromotionList);
  98.   PrefLoadFile(EnvFile);
  99.   ReleaseSemaphore(&MPSem->NodeSem);
  100. //  LVActive=0
  101.   ClosePrefs=TRUE;
  102. }
  103.  
  104. LONG SSecs=0;SMicros=0;
  105. struct DefaultNode *DCNode;
  106.  
  107. void GD_List(LONG Item, BOOL Keyed, struct IntuiMessage *IMsg)
  108. {
  109.   struct DefaultNode *n;
  110.   BOOL fullupdate=0;
  111.  
  112.   if(Item<0 )
  113.     Item=NodeCnt-1;
  114.   else
  115.     if(Item>=NodeCnt)
  116.       Item=0;
  117.   
  118.   LVActive=Item;
  119.   
  120.   n=GetActiveNode();
  121.   if(Keyed)
  122.     LG_SetGadgetAttrs(GadControl,GD_LIST,
  123.                     GTLV_Selected   ,LVActive,
  124.                     TAG_DONE);
  125.                     
  126.   if(IMsg)
  127.   {
  128.     if(DoubleClick(SSecs,SMicros,IMsg->Seconds,IMsg->Micros) && DCNode==n)
  129.     {
  130.       SSecs=0;
  131.       SMicros=0;
  132.       if(n)
  133.       {
  134.         n->Flags^=DNF_NEVER_PROMOTE;
  135.         fullupdate=1;
  136.       }
  137.     }
  138.     else
  139.     {
  140.       SSecs  =IMsg->Seconds;
  141.       SMicros=IMsg->Micros;
  142.     }
  143.     DCNode =n;
  144.   }
  145.   if(fullupdate)
  146.   {
  147.     UpdateGadgets();
  148.   }
  149.   else
  150.   {
  151.     LG_SetGadgetAttrs(GadControl,GD_MOVE,
  152.                       GTSL_Max,       NodeCnt-1,
  153.                       GTSL_Level,    (NodeCnt-1)-LVActive,
  154.                       GA_Disabled,    FALSE,
  155.                       TAG_DONE);
  156.     SetDispGadgets(n);
  157.     SetFontGadgets(n);
  158.     SetSharedGadgets(n);
  159.     SetPublicGadgets(n);
  160.     SetHotKeyGadgets(n);
  161.     SetOptionGadgets(n);
  162.     Set3DGadgets(n);
  163.     SetBackdropGadgets(n);
  164.   }
  165.     
  166.   ActivateStrGad=GD_NAME;
  167. }
  168.  
  169. void GD_SelectName(struct DefaultNode *N)
  170. {
  171.   LG_SetGadgetAttrs(GadControl,GD_LIST,
  172.                            GTLV_Labels,~0,
  173.                            TAG_DONE);
  174.   SelectName(N);
  175.   LG_SetGadgetAttrs(GadControl,GD_LIST,
  176.                            GTLV_Labels,&MPSem->PromotionList[CurrentList],
  177.                            TAG_DONE);
  178. }
  179.  
  180. void GD_ModeSel(struct DefaultNode *N, LONG Mode, BOOL Keyed)
  181. {
  182.   LONG maxmode,minmode;
  183.   
  184.   if(Keyed)
  185.   {
  186.     // if keyed Mode is dirchange
  187.     Mode+=N->ModeSelect;
  188.   } 
  189.   
  190.   maxmode=MS_PROMOTE_MAX;//                                                                            (4.57.3)
  191.   switch(N->Type)
  192.   {
  193.     case MPSEM_PLIST_PUBLICSCREENS:
  194.       if(!Keyed)
  195.         Mode+=2;
  196.       minmode=2;
  197.       break;
  198.     default:
  199.       minmode=0;
  200.   }      
  201.   
  202.   if(Mode>maxmode)
  203.     Mode=minmode;
  204.   else
  205.     if(Mode<minmode)
  206.       Mode=maxmode;
  207.  
  208.   N->ModeSelect=Mode;
  209.   SetDispGadgets(N);
  210. }
  211.  
  212. void GD_SelMode(struct DefaultNode *N)
  213. {
  214.   switch(N->ModeSelect)
  215.   {
  216.     case MS_PROMOTE_MONITOR:
  217.       SelectMonitor(N);
  218.       break;
  219.     case MS_PROMOTE_SCREENMODE:
  220.     case MS_PROMOTE_REQUESTER:
  221.       SelectScreenMode(Win,N,0);
  222.       break;
  223.     case MS_PROMOTE_BEST_MODE://                                                                       (4.57.14)
  224.       SelectMonitor(N);//                                                                              (4.57.14)
  225.       break;//                                                                                         (4.57.14)
  226.   }
  227.   SetDispGadgets(N);
  228.   SetOptionGadgets(N);
  229. }
  230.  
  231. /*
  232. void GD_Overscan(struct DefaultNode *N, LONG Value, BOOL Keyed)
  233. {
  234.   if(Keyed)
  235.   {
  236.     Value+=N->OverscanType-DNODE_OSCANTYPE_MIN;
  237.   }
  238.   
  239.   if(Value>DNODE_OSCANTYPE_MAX-DNODE_OSCANTYPE_MIN)
  240.     Value=0;
  241.   else
  242.   {
  243.     if(Value<0)
  244.       Value=DNODE_OSCANTYPE_MAX-DNODE_OSCANTYPE_MIN;
  245.   }
  246.  
  247.   N->OverscanType=Value+DNODE_OSCANTYPE_MIN;
  248.   
  249.   if(Keyed)
  250.   {
  251.     SetDispGadgets(N);
  252.   }
  253. }
  254. */
  255.  
  256. void GD_Overscan(struct DefaultNode *N, LONG Value, BOOL Keyed)
  257. {
  258.   if(Keyed)
  259.   {
  260.     Value+=N->OverscanType;
  261.   }
  262.   else
  263.   {
  264.     Value+=DNODE_OSCANTYPE_MIN;
  265.   }
  266.   
  267.   if(Value>DNODE_OSCANTYPE_MAX)
  268.     Value=DNODE_OSCANTYPE_MIN;
  269.  
  270.   if(Value<DNODE_OSCANTYPE_MIN)
  271.     Value=DNODE_OSCANTYPE_MAX;
  272.  
  273.   N->OverscanType=Value;
  274.  
  275.   if(Keyed)
  276.   {
  277.     SetDispGadgets(N);
  278.   }
  279. }
  280.  
  281.  
  282.  
  283. void GD_Remove(struct DefaultNode *N)
  284. {
  285.   ObtainSemaphore(&MPSem->NodeSem);
  286.   LG_SetGadgetAttrs(GadControl,GD_LIST,
  287.                     GTLV_Labels,~0,TAG_DONE);
  288.   if(!(N->Def_Node.ln_Succ->ln_Succ))
  289.     if(LVActive>0)
  290.       LVActive--;
  291.   Remove((struct Node *)N);
  292.   FreeDNode(N);
  293.   ReleaseSemaphore(&MPSem->NodeSem);
  294.   NodeCnt=CountNodes(&MPSem->PromotionList[CurrentList]); 
  295.   UpdateGadgets();
  296. }
  297.  
  298. void GD_PenList(struct DefaultNode *N, LONG Item,BOOL Keyed)
  299. {
  300.   if(Keyed)
  301.   {
  302.     Item+=ActivePen;
  303.   }
  304.   
  305.   if(Item>=NumDriPens)
  306.     Item=0;
  307.   else
  308.     if(Item<0)
  309.       Item=NumDriPens-1;
  310.   
  311.   ActivePen=Item;
  312.   if(N->Look3D)
  313.   {
  314.     ActivateStrGad=GD_PENVAL;
  315.     SetPenValues(N->Pens);
  316.   }
  317.   else
  318.     SetPenValues(0);
  319. }
  320.  
  321.  
  322. void GD_Interleave(struct DefaultNode *N, BOOL Set, BOOL Keyed)
  323. {
  324.   SetDNFlag(N,INTERLEAVE,Set,Keyed);
  325.  
  326.   if(Keyed)
  327.     SetOptionGadgets(N);
  328. }
  329.  
  330. BOOL SetDNFlag(struct DefaultNode *N, ULONG Flag, BOOL Set, BOOL Keyed)
  331. {
  332.   if(Keyed)
  333.   {
  334.     Set=!(N->Flags & Flag);
  335.   }
  336.   
  337.   N->Flags&=(~Flag);
  338.   if(Set)
  339.   {
  340.     N->Flags|=Flag;
  341.     return(1);
  342.   }
  343.   return(0);
  344.  
  345. }
  346.  
  347.  
  348.  
  349. void GD_Look3D(struct DefaultNode *N, BOOL Set, BOOL Keyed)
  350. {
  351.   if(Keyed)
  352.     N->Look3D=!N->Look3D;
  353.   else
  354.     N->Look3D=Set;
  355.     
  356.   Set3DGadgets(N);
  357. }
  358.  
  359. void GD_AutoScroll(struct DefaultNode *N, BOOL Set, BOOL Keyed)
  360. {
  361.   if(Keyed)
  362.     N->AutoScroll=!N->AutoScroll;
  363.   else
  364.     N->AutoScroll=Set;
  365.   
  366.   if(Keyed) 
  367.     SetOptionGadgets(N);
  368. }
  369. /*
  370. void GD_PenVal(struct DefaultNode *N, BOOL Flag)
  371. {
  372.   N->Pens[ActivePen]=GetGadNumber(GadControl,GD_PENVAL]);
  373.   if(imsg->Qualifier&3)
  374.   {
  375.     ActivePen--;
  376.     if(ActivePen<0) ActivePen=NumDriPens-1;
  377.   }
  378.   else
  379.   {
  380.     ActivePen++;
  381.     if(ActivePen>=NumDriPens) ActivePen=0;
  382.   }
  383.   ActivateStrGad=GD_PENVAL;
  384.   SetPenValues(N->Pens);
  385. }
  386. */
  387. void GD_ResetPens(struct DefaultNode *N)
  388. {
  389.   LONG l;
  390.  
  391.   if(N->Look3D)
  392.   {
  393.     ObtainSemaphore(&MPSem->NodeSem);
  394.     for(l=0;l<NumDriPens;l++)
  395.       N->Pens[l]=defaultpens[l];
  396.     ReleaseSemaphore(&MPSem->NodeSem);
  397.     SetPenValues(N->Pens);
  398.   }
  399. }
  400.  
  401. void GD_PickFont(struct DefaultNode *N)
  402. {
  403.   if(PickFont(Win,&N->Font))
  404.     SetFontGadgets(N);
  405. }
  406.  
  407. void GD_Center(struct DefaultNode *N, LONG Num, BOOL Keyed)
  408. {
  409.   if(Keyed)
  410.     Num+=N->CenterFlags;
  411.   
  412.   if(Num>MAX_CENTERFLAG)
  413.     Num=0;
  414.  
  415.   if(Num<0)
  416.     Num=MAX_CENTERFLAG;
  417.  
  418.   N->CenterFlags=Num;
  419.  
  420.   if(Keyed)
  421.     SetOptionGadgets(N);
  422. }
  423.  
  424. void GD_FAspect(struct DefaultNode *N, BOOL Set, BOOL Keyed)
  425. {
  426.   SetDNFlag(N,FIXASPECT,Set,Keyed);
  427.   
  428.   if(Keyed)
  429.     SetFontGadgets(N);
  430. }
  431.  
  432. void GD_SFont(struct DefaultNode *N, LONG Code, BOOL Keyed)
  433. {
  434.   if(Keyed)
  435.   {
  436.     Code+=N->FontType;
  437.   }
  438.   
  439.   if(Code>=MAX_FONT)
  440.     Code=0;
  441.   else
  442.     if(Code<0)
  443.       Code=MAX_FONT-1;
  444.       
  445.   N->FontType=Code;
  446.   SetFontGadgets(N);
  447. }
  448.  
  449. void GD_PubOpt(struct DefaultNode *N, BOOL Set, BOOL Keyed)
  450. {
  451.   if(Keyed)
  452.   {
  453.     Set=!(N->PubOptions);
  454.   }
  455.   
  456.   if(Set)
  457.   {
  458.     N->PubOptions=1;
  459.     ActivateStrGad=GD_PUBNAME;
  460.   }
  461.   else
  462.   {
  463.     N->PubOptions=0;
  464.   }
  465.  
  466.   SetPublicGadgets(N);
  467. }
  468.   
  469. void GD_DoDepth(struct DefaultNode *N, BOOL Set, BOOL Keyed)
  470. { 
  471.   SetDNFlag(N,DEPTH,Set,Keyed);
  472.   
  473.   SetDepthGadgets(N);
  474. }
  475.   
  476. void GD_SharePens(struct DefaultNode *N, BOOL Set, BOOL Keyed)
  477. {
  478.   if(SetDNFlag(N,SHAREPENS,Set,Keyed))
  479.   {
  480.     ActivateStrGad=GD_LOCKEDPENS;
  481.   }
  482.   SetSharedGadgets(N);
  483. }
  484.   
  485. void GD_HotKeyOpt(struct DefaultNode *N, BOOL Set, BOOL Keyed)
  486. {
  487.   if(SetDNFlag(N,SCRHOTKEY,Set,Keyed))
  488.   {
  489.     ActivateStrGad=GD_HOTKEYSTR;
  490.   }
  491.   SetHotKeyGadgets(N);
  492. }
  493.   
  494. void GD_Palette(struct DefaultNode *N, BOOL Set, BOOL Keyed)
  495. {
  496.   SetDNFlag(N,DNF_PALETTE,Set,Keyed);
  497.   SetPaletteGadgets(N);
  498. }
  499.  
  500. void GD_EditPalette(struct DefaultNode *N)
  501. {
  502.   switch(N->ModeSelect)
  503.   {
  504.     case MS_PROMOTE_SCREENMODE:
  505.     case MS_PROMOTE_REQUESTER:
  506.     case MS_PROMOTE_BEST_MODE:
  507.       if(N->Flags&DNF_PALETTE)
  508.         PaletteReq(N);
  509.       break;
  510.   }
  511. }
  512.  
  513. void GD_Move(LONG Num, BOOL Keyed)
  514. {
  515.   BOOL uplist=0;
  516.   struct DefaultNode *n,*wn;
  517.  
  518.   if(Keyed)
  519.   {
  520.     Num+=LVActive;
  521.   }
  522.  
  523.   if(Num>=NodeCnt)
  524.     Num=0;
  525.   else
  526.     if(Num<0)
  527.       Num=NodeCnt-1;
  528.       
  529.   
  530.   if(NodeCnt)
  531.   {
  532.     ObtainSemaphore(&MPSem->NodeSem);
  533.     n=GetActiveNode();
  534.     Num=(NodeCnt-1)-Num;
  535.     if(Num<LVActive) uplist=TRUE;
  536.     LVActive=Num;
  537.     if(wn=GetActiveNode())
  538.       if(uplist) wn=(struct DefaultNode *)wn->Def_Node.ln_Pred;
  539.         if(wn!=n)
  540.         {
  541.           LG_SetGadgetAttrs(GadControl,GD_LIST,
  542.                    GTLV_Labels,~0,
  543.                    TAG_DONE);
  544.           Remove((struct Node *)n);
  545.           Insert(&MPSem->PromotionList[CurrentList],(struct Node *)n,(struct Node *)wn);
  546.           LG_SetGadgetAttrs(GadControl,GD_LIST,
  547.                    GTLV_Labels,&MPSem->PromotionList[CurrentList],
  548.                    GTLV_MakeVisible,LVActive,
  549.                    GTLV_Selected,LVActive,TAG_DONE);
  550.         }  
  551.     ReleaseSemaphore(&MPSem->NodeSem); 
  552.   }
  553. }
  554.  
  555.  
  556. void GD_Depth(struct DefaultNode *N, LONG Depth, BOOL Keyed)
  557. {
  558.   LONG maxdepth;
  559.   
  560.   if(Keyed)
  561.     Depth+=N->Depth;
  562.   
  563.   if((N->ModeSelect==MS_PROMOTE_SCREENMODE || N->ModeSelect==MS_PROMOTE_REQUESTER || N->ModeSelect==MS_PROMOTE_BEST_MODE) && N->Flags & (DEPTH | DNF_PALETTE))//  (4.57.12)
  564.   {
  565.     if(Keyed)
  566.     {
  567.       struct DimensionInfo di;
  568.     
  569.  
  570.       if(GetDisplayInfoData(NULL,(UBYTE *)&di,sizeof(di),DTAG_DIMS,N->ModeID)>0)
  571.       {
  572.         maxdepth=DepthToSlider[min(di.MaxDepth,32)];//                                                 (4.57.20)
  573.         
  574.         if(Depth>maxdepth)
  575.           Depth=1;
  576.         else
  577.           if(Depth<1)
  578.             Depth=maxdepth;
  579.       }
  580.       else
  581.         Depth=1;
  582.       
  583.       LG_SetGadgetAttrs(GadControl,GD_DEPTH,
  584.                       GTSL_Level      ,Depth,
  585.                       TAG_DONE);
  586.     }
  587.     
  588.     N->Depth=SliderToDepth[Depth];//                                                                   (4.57.21)
  589.     WriteColorDisp(N);
  590.   }
  591. }
  592.  
  593. void GD_Force_Planar(struct DefaultNode *N, BOOL Set, BOOL Keyed)
  594. {
  595.   SetDNFlag(N,DNF_FORCEPLANAR,Set,Keyed);
  596.   
  597.   if(Keyed)
  598.     SetOptionGadgets(N);      
  599. }
  600.  
  601. void GD_Blank_Border(struct DefaultNode *N, BOOL Set, BOOL Keyed)
  602. {
  603.   SetDNFlag(N,DNF_BLANK_BORDER,Set,Keyed);
  604.   
  605.   if(Keyed) 
  606.     SetOptionGadgets(N);
  607. }
  608.  
  609. void GD_Behind(struct DefaultNode *N, BOOL Set, BOOL Keyed)
  610. {
  611.   SetDNFlag(N,DNF_BEHIND,Set,Keyed);
  612.   
  613.   if(Keyed) 
  614.     SetOptionGadgets(N);
  615. }
  616.  
  617. void GD_3D_Default(struct DefaultNode *N, BOOL Set, BOOL Keyed)
  618. {
  619.   SetDNFlag(N,DNF_3D_DEFAULT,Set,Keyed);
  620.  
  621.   Set3DGadgets(N);
  622. }
  623.  
  624. void GD_BackdropOpt(struct DefaultNode *N, LONG Flag, BOOL Keyed)
  625. {
  626.   if(Keyed)
  627.   {
  628.     N->BackdropType+=Flag;
  629.     if(N->BackdropType<0)
  630.       N->BackdropType=DNODE_BACKDROPTYPE_MAX;
  631.     if(N->BackdropType>DNODE_BACKDROPTYPE_MAX)
  632.       N->BackdropType=0;
  633.   }
  634.   else
  635.   {
  636.     N->BackdropType=Flag;
  637.   }
  638.   
  639.   if(N->BackdropType==DNODE_BACKDROPTYPE_IMAGE)
  640.     N->BackdropFlags|=BF_ON; // compatibility for pre-4.47
  641.     
  642.   SetBackdropGadgets(N);
  643. }
  644.  
  645. void GD_BackdropPick(struct DefaultNode *N)
  646. {
  647.   if(N)
  648.   {
  649.     if(SelectBackdropFile(GetString(MSG_BREQ_SELECT_BACKDROP),Win,N->BackdropFile))
  650.     {
  651.       FreeVec(N->BackdropFile);
  652.       N->BackdropFile=CopyString(filename,MEMF_PUBLIC);
  653.       SetBackdropGadgets(N);
  654.     }
  655.   }
  656. }
  657.  
  658. ULONG my_DoRequest(Object *Obj, Tag Tags,...);
  659.  
  660. void GD_BackdropCenter(struct DefaultNode *N, BOOL Set, BOOL Keyed)
  661. {
  662.   if(Keyed)
  663.   {
  664.     Set=!(N->BackdropFlags & BF_CENTER);
  665.   }
  666.   
  667.   N->BackdropFlags&=~BF_CENTER;
  668.   if(Set)
  669.     N->BackdropFlags|=BF_CENTER;
  670.   
  671.   if(Keyed)
  672.     SetBackdropGadgets(N);      
  673. }
  674.  
  675. /*
  676. #include <boopsi/requesters/root.h>
  677. #include <boopsi/requesters/palette.h>
  678.  
  679. void GD_BackdropColor(struct DefaultNode *N, BOOL Keyed)
  680. {
  681.   Object *BackdropPReq=0;
  682.   
  683.   if(!BackdropPReq)
  684.   {
  685.     LONG width;
  686.     
  687.     width=Win->Width/2;
  688.     BackdropPReq=NewObject(0,"palette.requester",
  689.                 PR_Colors,          1,
  690.                 PR_TextAttr,        TAttr,
  691.                 PR_ObtainPens,      1,
  692.                 PR_InitialLeftEdge, Win->LeftEdge+width/2,
  693.                 PR_InitialTopEdge,  Win->TopEdge+8,
  694.                 PR_InitialWidth,    width,
  695.                 PR_InitialHeight,   Win->Height-16,
  696.                 TAG_DONE);
  697.   }
  698.   
  699.   if(BackdropPReq)
  700.   {
  701.     if(my_DoRequest(BackdropPReq,
  702.                       PR_Window,  Win,
  703.                       PR_InitialPalette,  &N->BackdropRGB,
  704.                       TAG_DONE))
  705.     {
  706.       struct RGB *p;
  707.       
  708. //      p=(struct RGB *)BackdropPReq->pr_Palette;
  709. //      N->BackdropRGB=*p;      
  710.       SetBackdropGadgets(N);
  711.     }
  712.     DisposeObject(BackdropPReq);
  713.   }
  714. }
  715.  
  716. ULONG my_DoRequest(Object *Obj, Tag Tags,...)
  717. {
  718.   return(DoMethod(Obj, RM_DOREQUEST, &Tags));
  719. }
  720. */
  721.  
  722. #include <clib/extras/palettereq_protos.h>
  723. #include <extras/palettereq.h>
  724. extern  struct PaletteRequest *BackdropPReq;
  725.  
  726. void GD_BackdropColor(struct DefaultNode *N, BOOL Keyed)
  727. {
  728.   if(!BackdropPReq)
  729.   {
  730.     LONG width;
  731.     
  732.     width=Win->Width/2;
  733.     BackdropPReq=PR_AllocPaletteRequest(
  734.                 PR_Colors,          1,
  735.                 PR_TextAttr,        TAttr,
  736.                 PR_ObtainPens,      1,
  737.                 PR_InitialLeftEdge, Win->LeftEdge+width/2,
  738.                 PR_InitialTopEdge,  Win->TopEdge+8,
  739.                 PR_InitialWidth,    width,
  740.                 PR_InitialHeight,   Win->Height-16,
  741.                 TAG_DONE);
  742.   }
  743.   
  744.   if(BackdropPReq)
  745.   {
  746.     if(PR_DoPaletteRequest(BackdropPReq, 
  747.                       PR_Window,  Win,
  748.                       PR_InitialPalette,  &N->BackdropRGB,
  749.                       TAG_DONE))
  750.     {
  751.       struct RGB *p;
  752.       
  753.       p=(struct RGB *)BackdropPReq->pr_Palette;
  754.       N->BackdropRGB=*p;      
  755.       SetBackdropGadgets(N);
  756.     }
  757. //    PR_FreePaletteRequest(BackdropPReq); // freed in CleanUp()
  758.   }
  759. }
  760.  
  761.  
  762.  
  763. void GD_FE_SaveUse(void)
  764. {
  765.   ReturnFEMsg(MPFE_SAVEUSE);
  766. }
  767.  
  768. void GD_FE_UseDelete(void)
  769. {
  770.   ReturnFEMsg(MPFE_USEDELETE);
  771. }
  772.  
  773. void GD_FE_Never(void)
  774. {
  775.   ReturnFEMsg(MPFE_NEVER);
  776. }
  777.  
  778. void GD_FE_Cancel(void)
  779. {
  780.   ReturnFEMsg(MPFE_CANCEL);
  781. }
  782.  
  783. void ReturnFEMsg(ULONG Code)
  784. {
  785.   if(ForcedEditMsg)
  786.   {
  787.     ForcedEditMsg->Code=Code;
  788.     ReplyMsg((struct Message *)ForcedEditMsg);
  789.   }
  790.   
  791.   if(!(ForcedEditMsg=(struct MPMessage *)GetMsg(&MPSem->PrefsToDoPort)))//                             (4.62.7)
  792.   {
  793.     RemakeGads();
  794.   }
  795. //  LVActive=0;
  796. }
  797.  
  798. /*
  799. void ReturnFEMsg(ULONG Code)
  800. {
  801.   struct MPMessage *mpm;
  802.   
  803.   if(mpm=(struct MPMessage *)RemHead(&ForcedEditList))
  804.   {
  805.     mpm->Code=Code;
  806.     ReplyMsg((struct Message *)mpm);
  807.   }
  808.   if(IsListEmpty(&ForcedEditList))
  809.     ForcedEditMode=0;
  810.   
  811.   RemakeGads();
  812. }*/
  813.